home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / xarchie-2.0.9 / types.c < prev    next >
C/C++ Source or Header  |  1995-06-18  |  12KB  |  411 lines
  1. /*
  2.  * types.c : Converters for SearchType and SortType, a converter for
  3.  *    fonts that allows per-application defaults, and an improved
  4.  *    converter for Widget that allows "NULL" to be specified.
  5.  *
  6.  * George Ferguson, ferguson@cs.rochester.edu, 12 Sep 1991.
  7.  * Version 2.0: 23 Apr 1993: For pre-R5 systems, we include the string-
  8.  *                     to-font-struct converter.
  9.  * 30 Jun 1993: Removed extra quotes in stringToSearchType().
  10.  */
  11.  
  12. #include <X11/IntrinsicP.h>
  13. #include <X11/StringDefs.h>
  14. #include <X11/Xaw/Form.h>
  15. #include <X11/Xaw/Cardinals.h>
  16. #include "types.h"
  17. #include "xarchie.h"
  18. #include "appres.h"
  19. #include "stringdefs.h"
  20. extern void XmuCvtStringToWidget();    /* original old-style converter */
  21.  
  22. /*
  23.  * In R5, more of the default converters are available externally.
  24.  * For R4 however, the string-to-font converters are static, so we
  25.  * include the appropriate code below.
  26.  */
  27. #if XtSpecificationRelease<5
  28. static Boolean CvtStringToFontStruct();        /* original static converter */
  29. static int CompareISOLatin1();
  30. #else
  31. extern Boolean XtCvtStringToFontStruct();    /* original converter */
  32. #endif
  33.  
  34. /*
  35.  * Functions defined here:
  36.  */
  37. void initConverters();
  38. SearchType stringToSearchType();
  39. SortType stringToSortType();
  40. char *searchTypeToString(),*sortTypeToString();
  41.  
  42. static void strcpyLowered();
  43. static Boolean cvtStringToSearchType(),cvtStringToSortType();
  44. static Boolean cvtStringToFontStruct();
  45. static void cvtStringToWidget(); /* old-style converter */
  46.  
  47. /* Straight from the Xt manual... */
  48. #define done(TYPE,VALUE)\
  49. {                            \
  50.     if (toVal->addr != NULL) {                \
  51.     if (toVal->size < sizeof(TYPE)) {        \
  52.         toVal->size = sizeof(TYPE);            \
  53.         return(False);                \
  54.     }                        \
  55.     *(TYPE *)(toVal->addr) = (VALUE);        \
  56.     } else {                        \
  57.     static TYPE static_val;                \
  58.     static_val = (VALUE);                \
  59.     toVal->addr = (XtPointer)&static_val;        \
  60.     }                            \
  61.     toVal->size = sizeof(TYPE);                \
  62.     return(True);                    \
  63. }
  64.                             
  65. void
  66. initConverters(appContext)
  67. XtAppContext appContext;
  68. {
  69.     static XtConvertArgRec parentCvtArgs[] = {
  70.         {XtBaseOffset, (caddr_t)XtOffset(Widget, core.parent), sizeof(Widget)}
  71.     };
  72.     static XtConvertArgRec displayCvtArgs[] = {
  73.     {XtAddress, (XtPointer)&display, sizeof(Display*)},
  74.     };
  75.  
  76.     /* Specify XtCacheNone for some reason, broke otherwise */
  77.     XtSetTypeConverter(XtRString,GfRSearchType,cvtStringToSearchType,
  78.                NULL,ZERO,XtCacheNone,NULL);
  79.     XtSetTypeConverter(XtRString,GfRSortType,cvtStringToSortType,
  80.                NULL,ZERO,XtCacheNone,NULL);
  81.     /* Override default here */
  82.     XtSetTypeConverter(XtRString,XtRFontStruct,cvtStringToFontStruct,
  83.                displayCvtArgs,XtNumber(displayCvtArgs),
  84.                XtCacheByDisplay,NULL);
  85.     /* Have to initialize Form class first or our converter will be    */
  86.     /* overidden by the class initialization function.            */
  87.     /* Use the old style here on purpose since that what the default is.*/
  88.     XtInitializeWidgetClass(formWidgetClass);
  89.     XtAppAddConverter(appContext,XtRString,XtRWidget,cvtStringToWidget,
  90.                     parentCvtArgs,XtNumber(parentCvtArgs));
  91. }
  92.  
  93. /*    -    -    -    -    -    -    -    -    */
  94. /* Xt converters */
  95. static void
  96. strcpyLowered(dst,src)
  97. char *dst,*src;
  98. {
  99.     do {
  100.     if (*src >= 'A' && *src <= 'Z')
  101.         *dst++ = *src - 'A' + 'a';
  102.     else
  103.         *dst++ = *src;
  104.     } while (*src++);
  105. }
  106.  
  107. /* ARGSUSED */
  108. static Boolean
  109. cvtStringToSearchType(display,args,num_args,fromVal,toVal,data)
  110.     Display *display;
  111.     XrmValuePtr args;        /* unused */
  112.     Cardinal    *num_args;      /* unused */
  113.     XrmValuePtr fromVal;
  114.     XrmValuePtr toVal;
  115.     XtPointer *data;        /* unused */
  116. {
  117.     char message[256];
  118.     SearchType type;
  119.  
  120.     strcpyLowered(message,(char*)(fromVal->addr));
  121.     if ((type=stringToSearchType(message)) != GfError)
  122.     done(SearchType,type);
  123.     XtDisplayStringConversionWarning(display,fromVal->addr,GfRSearchType);
  124.     toVal->addr = NULL;
  125.     toVal->size = 0;
  126.     return(False);
  127. }
  128.  
  129. /* ARGSUSED */
  130. static Boolean
  131. cvtStringToSortType(display,args,num_args,fromVal,toVal,data)
  132.     Display *display;
  133.     XrmValuePtr args;        /* unused */
  134.     Cardinal    *num_args;      /* unused */
  135.     XrmValuePtr fromVal;
  136.     XrmValuePtr toVal;
  137.     XtPointer *data;        /* unused */
  138. {
  139.     char message[256];
  140.     SortType type;
  141.  
  142.     strcpyLowered(message,(char*)(fromVal->addr));
  143.     if ((type=stringToSortType(message)) != GfError)
  144.     done(SortType,type);
  145.     XtDisplayStringConversionWarning(display,fromVal->addr,GfRSortType);
  146.     toVal->addr = NULL;
  147.     toVal->size = 0;
  148.     return(False);
  149. }
  150.  
  151. /*    -    -    -    -    -    -    -    -    */
  152. /*
  153.  * cvtStringToFontStruct() : This just checks for the two special names
  154.  *    "xarchieFont" and "xarchieBoldFont" and returns the appropriate
  155.  *    application resource. Otherwise invokes the default converter.
  156.  */
  157.  
  158. /* ARGSUSED */
  159. static Boolean
  160. cvtStringToFontStruct(display,args,num_args,fromVal,toVal,data)
  161.     Display *display;
  162.     XrmValuePtr args;
  163.     Cardinal    *num_args;
  164.     XrmValuePtr fromVal;
  165.     XrmValuePtr toVal;
  166.     XtPointer *data;
  167. {
  168.     char message[256];
  169.  
  170.     strcpyLowered(message,(char*)(fromVal->addr));
  171.     if (strcmp(message,"xarchiefont") == 0)
  172.     done(XFontStruct*,appResources.xarchieFont);
  173.     if (strcmp(message,"xarchieboldfont") == 0)
  174.     done(XFontStruct*,appResources.xarchieBoldFont);
  175. #if XtSpecificationRelease<5
  176.     return(CvtStringToFontStruct(display,args,num_args,fromVal,toVal,data));
  177. #else
  178.     return(XtCvtStringToFontStruct(display,args,num_args,fromVal,toVal,data));
  179. #endif
  180. }
  181.  
  182. /*    -    -    -    -    -    -    -    -    */
  183. /*
  184.  * cvtStringToWidget() : Allows us to specify "NULL" as a widget name in
  185.  *    a resource file to override compiled-in defaults for composite
  186.  *    widget layouts. Simply calls the regular converter if the string
  187.  *    is not "NULL". Note that this must be registered *after* the
  188.  *    Form class is initialized.
  189.  */
  190. static void
  191. cvtStringToWidget(args,num_args,fromVal,toVal)
  192. XrmValuePtr args;
  193. Cardinal *num_args;
  194. XrmValuePtr fromVal;
  195. XrmValuePtr toVal;
  196. {
  197.     if (strcasecmp(fromVal->addr,"null") == 0) {
  198.     toVal->addr = NULL;
  199.     toVal->size = 0;
  200.     } else {
  201.     XmuCvtStringToWidget(args,num_args,fromVal,toVal);
  202.     }
  203. }
  204.  
  205. /*    -    -    -    -    -    -    -    -    */
  206. /* Useful generic converters */
  207.  
  208. SearchType
  209. stringToSearchType(s)
  210. char *s;
  211. {
  212.     if (strcmp(s,GfNExact) == 0)
  213.     return(GfExact);
  214.     if (strcmp(s,GfNSubstr) == 0)
  215.     return(GfSubstr);
  216.     if (strcmp(s,GfNSubcase) == 0)
  217.     return(GfSubcase);
  218.     if (strcmp(s,GfNRegexp) == 0)
  219.     return(GfRegexp);
  220.     if (strcmp(s,GfNExactSubstr) == 0)
  221.     return(GfExactSubstr);
  222.     if (strcmp(s,GfNExactSubcase) == 0)
  223.     return(GfExactSubcase);
  224.     if (strcmp(s,GfNExactRegexp) == 0)
  225.     return(GfExactRegexp);
  226.     return(GfError);
  227. }
  228.  
  229. char *
  230. searchTypeToString(type)
  231. SearchType type;
  232. {
  233.     switch (type) {
  234.     case GfExact :        return(GfNExact);
  235.     case GfSubstr :     return(GfNSubstr);
  236.     case GfSubcase :    return(GfNSubcase);
  237.     case GfRegexp :      return(GfNRegexp);
  238.     case GfExactSubstr :    return(GfNExactSubstr);
  239.     case GfExactSubcase :    return(GfNExactSubcase);
  240.     case GfExactRegexp :    return(GfNExactRegexp);
  241.     default: return("UNKNOWN");
  242.     }
  243. }
  244.  
  245. SortType
  246. stringToSortType(s)
  247. char *s;
  248. {
  249.     if (strcmp(s,GfNName) == 0)
  250.     return(GfName);
  251.     if (strcmp(s,GfNDate) == 0)
  252.     return(GfDate);
  253.     if (strcmp(s,GfNWeight) == 0)
  254.     return(GfWeight);
  255.     return(GfError);
  256. }
  257.  
  258. char *
  259. sortTypeToString(type)
  260. SortType type;
  261. {
  262.     switch (type) {
  263.     case GfName : return(GfNName);
  264.     case GfDate : return(GfNDate);
  265.     case GfWeight : return(GfNWeight);
  266.     default: return("UNKNOWN");
  267.     }
  268. }
  269.  
  270. /*    -    -    -    -    -    -    -    -    */
  271. /* The string-to-font-struct converter was static in R4 (and earlier?)
  272.  * so we include it here if necessary. This code is taken from the
  273.  * file lib/Xt/Converters.c in the R4 distribution.
  274.  */
  275.  
  276. #if XtSpecificationRelease<5
  277. /***********************************************************
  278. Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts,
  279. and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
  280.  
  281.                         All Rights Reserved
  282.  
  283. Permission to use, copy, modify, and distribute this software and its 
  284. documentation for any purpose and without fee is hereby granted, 
  285. provided that the above copyright notice appear in all copies and that
  286. both that copyright notice and this permission notice appear in 
  287. supporting documentation, and that the names of Digital or MIT not be
  288. used in advertising or publicity pertaining to distribution of the
  289. software without specific, written prior permission.  
  290.  
  291. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  292. ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  293. DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  294. ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  295. WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  296. ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  297. SOFTWARE.
  298.  
  299. ******************************************************************/
  300.  
  301. #include <X11/keysym.h>
  302. #include <X11/Quarks.h>
  303.  
  304. /*ARGSUSED*/
  305. static Boolean
  306. CvtStringToFontStruct(dpy, args, num_args, fromVal, toVal, closure_ret)
  307.     Display*    dpy;
  308.     XrmValuePtr args;
  309.     Cardinal    *num_args;
  310.     XrmValuePtr    fromVal;
  311.     XrmValuePtr    toVal;
  312.     XtPointer    *closure_ret;
  313. {
  314.     XFontStruct        *f;
  315.     Display*    display;
  316.  
  317.     if (*num_args != 1)
  318.      XtAppErrorMsg(XtDisplayToApplicationContext(dpy),
  319.          "wrongParameters","cvtStringToFontStruct","XtToolkitError",
  320.              "String to font conversion needs display argument",
  321.               (String *) NULL, (Cardinal *)NULL);
  322.  
  323.     display = *(Display**)args[0].addr;
  324.  
  325.     if (CompareISOLatin1((String)fromVal->addr, XtDefaultFont) != 0) {
  326.     f = XLoadQueryFont(display, (char *)fromVal->addr);
  327.     if (f != NULL) {
  328.   Done:        done( XFontStruct*, f);
  329.     }
  330.  
  331.     XtDisplayStringConversionWarning( dpy, (char*)fromVal->addr,
  332.                       "FontStruct" );
  333.     }
  334.  
  335.     /* try and get the default font */
  336.  
  337.     {
  338.     XrmName xrm_name[2];
  339.     XrmClass xrm_class[2];
  340.     XrmRepresentation rep_type;
  341.     XrmValue value;
  342.  
  343.     xrm_name[0] = XrmStringToName ("xtDefaultFont");
  344.     xrm_name[1] = NULL;
  345.     xrm_class[0] = XrmStringToClass ("XtDefaultFont");
  346.     xrm_class[1] = NULL;
  347.     if (XrmQGetResource(XtDatabase(dpy), xrm_name, xrm_class, 
  348.                 &rep_type, &value)) {
  349.         if (rep_type == XtQString) {
  350.         f = XLoadQueryFont(display, (char*)value.addr);
  351.         if (f != NULL)
  352.             goto Done;
  353.         else {
  354.             XtDisplayStringConversionWarning( dpy, (char*)value.addr,
  355.                               "FontStruct" );
  356.         }
  357.         } else if (rep_type == XtQFont) {
  358.         f = XQueryFont(dpy, *(Font*)value.addr );
  359.         if (f != NULL) goto Done;
  360.         } else if (rep_type == XtQFontStruct) {
  361.         f = (XFontStruct*)value.addr;
  362.         goto Done;
  363.         }
  364.     }
  365.     }
  366.     /* Should really do XListFonts, but most servers support this */
  367.     f = XLoadQueryFont(dpy,"-*-*-*-R-*-*-*-120-*-*-*-*-ISO8859-1");
  368.     if (f != NULL)
  369.     goto Done;
  370.  
  371.     XtAppErrorMsg(XtDisplayToApplicationContext(dpy),
  372.          "noFont","cvtStringToFontStruct","XtToolkitError",
  373.              "Unable to load any useable ISO8859-1 font",
  374.               (String *) NULL, (Cardinal *)NULL);
  375.     
  376.     return False;
  377. }
  378.  
  379. static int CompareISOLatin1 (first, second)
  380.     char *first, *second;
  381. {
  382.     register unsigned char *ap, *bp;
  383.  
  384.     for (ap = (unsigned char *) first, bp = (unsigned char *) second;
  385.      *ap && *bp; ap++, bp++) {
  386.     register unsigned char a, b;
  387.  
  388.     if ((a = *ap) != (b = *bp)) {
  389.         /* try lowercasing and try again */
  390.  
  391.         if ((a >= XK_A) && (a <= XK_Z))
  392.           a += (XK_a - XK_A);
  393.         else if ((a >= XK_Agrave) && (a <= XK_Odiaeresis))
  394.           a += (XK_agrave - XK_Agrave);
  395.         else if ((a >= XK_Ooblique) && (a <= XK_Thorn))
  396.           a += (XK_oslash - XK_Ooblique);
  397.  
  398.         if ((b >= XK_A) && (b <= XK_Z))
  399.           b += (XK_a - XK_A);
  400.         else if ((b >= XK_Agrave) && (b <= XK_Odiaeresis))
  401.           b += (XK_agrave - XK_Agrave);
  402.         else if ((b >= XK_Ooblique) && (b <= XK_Thorn))
  403.           b += (XK_oslash - XK_Ooblique);
  404.  
  405.         if (a != b) break;
  406.     }
  407.     }
  408.     return (((int) *bp) - ((int) *ap));
  409. }
  410. #endif /* <R5 */
  411.